package com.bwie;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author: lrz
 * @Date: 2024/11/20 18:49
 * @Description:
 **/
public class Test {
    public static void main(String[] args) {

//        3.	创建订单列表（10分）
//¢	创建一个包含多个Order实例的List<Order>。
//¢	每个Order应至少包含两个OrderItem
        List<Orderltem> orderltems1 = Arrays.asList(
                new Orderltem(1, 1, 1, 1),
                new Orderltem(2, 2, 2, 2),
                new Orderltem(3, 3, 3, 3)
        );
        Order order1 = new Order(1, "1", orderltems1, 1);

        List<Orderltem> orderltems2 = Arrays.asList(
                new Orderltem(1, 4, 1, 60),
                new Orderltem(2, 5, 2, 80),
                new Orderltem(3, 6, 3, 3)
        );
        Order order2 = new Order(1, "1", orderltems2, 2);

        ArrayList<Order> orders = new ArrayList<>();
        orders.add(order1);
        orders.add(order2);

//        4.	筛选已完成的订单（10分）
//¢	使用Stream API从订单列表中筛选出状态为“已完成”的订单。
        orders.stream().filter(order -> order.getStatus() == 2).forEach(order -> System.out.println("第四题："+order.toString()));

//        5.	计算某个客户的订单总额（10分）
//¢	给定一个customerId，计算该客户所有订单的总价（即所有OrderItem的价格乘以数量之和）。
        double totalPrice = orders.stream()
                .filter(order -> order.getCustomerld().equals("1"))
                .flatMap(order -> order.getOrderltems().stream())
                .mapToInt(orderltem -> orderltem.getPrice() * orderltem.getQuantity())
                .sum();
        System.out.println("第五题:"+totalPrice);

//        6.	统计每个产品的订单数量（10分）
//¢	统计每个产品被订购的次数，并返回一个Map<ProductId, Integer>。
        orders.stream()
                .flatMap(order -> order.getOrderltems().stream())
                .collect(Collectors.groupingBy(Orderltem::getProductld, Collectors.summingInt(Orderltem::getQuantity)))
                .forEach((productId, quantity) -> System.out.println("产品ID：" + productId + ", 订单数量：" + quantity));

//        7.	找到总价最高的订单（10分）
//¢	使用Stream API找到总价最高的订单，并返回该订单。
        Order maxOrder = orders.stream()
                .max((o1, o2) -> Double.compare(o1.getOrderltems().stream().mapToInt(orderltem -> orderltem.getPrice() * orderltem.getQuantity()).sum(),
                        o2.getOrderltems().stream().mapToInt(orderltem -> orderltem.getPrice() * orderltem.getQuantity()).sum()))
                .orElse(null);
        System.out.println("第七题："+maxOrder);

//        8.	按照订单总价排序（10分）
//¢	将订单列表按照总价从高到低排序。
        orders.stream()
                .sorted((o1, o2) -> Double.compare(o2.getOrderltems().stream().mapToInt(orderltem -> orderltem.getPrice() * orderltem.getQuantity()).sum(),
                        o1.getOrderltems().stream().mapToInt(orderltem -> orderltem.getPrice() * orderltem.getQuantity()).sum()))
                .forEach(order -> System.out.println("第八题："+order.toString()));

//        9.	过滤特定价格范围的产品（10分）
//¢	过滤出所有单价在特定区间（如50元至100元之间）内的产品，并返回这些产品的ProductId。
        List<Integer> productIds = orders.stream()
                .flatMap(order -> order.getOrderltems().stream())
                .filter(orderltem -> orderltem.getPrice() >= 50 && orderltem.getPrice() <= 100)
                .map(Orderltem::getProductld)
                .distinct()
                .collect(Collectors.toList());
        System.out.println("第九题："+productIds);

//        10.	统计订单状态分布（10分）
//¢	统计订单的不同状态的数量，并返回一个Map<Status, Long>。
        Map<Integer, Long> statusCounts = orders.stream()
                .collect(Collectors.groupingBy(Order::getStatus, Collectors.counting()));
        System.out.println("第十题："+statusCounts);









    }
}
